const express = require('express');
const router = express.Router();
const Admin = require('../../models/Admin');
const Session = require('../../models/Session');
const Message = require('../../models/Message');
const authenticateToken = require('../../middlewares/authenticateToken');


//获取客服列表（不限在线状态）
router.get('/service/list', authenticateToken, async (req, res) => {
  try {
    const List=await Admin.find({role:'customer_service'})
    res.json({
      code: '0000',
      msg: '获取客服列表成功',
      data: List
    });
  } catch (err) {
    res.json({ code: '2001', msg: '获取客服列表失败: ' + err.message, data: null });
  }
});

//创建新会话，作家创建与指定客服的会话
router.post('/service/create', authenticateToken, async (req, res) => {
    // 后端/service/create接口里，开头加日志：
  console.log('req.user:', req.user); // 看是否有id字段
  console.log('req.body:', req.body); // 看是否有adminId
  const adminId = req.body.adminId;
  console.log('adminId:', adminId); // 看adminId是否有值
  try {
    //const { adminId } = req.body; // 前端传入的客服ID（变量名保留，用于查询Admin）
    const writerId = req.user.id; // 从Token解析的作家ID（变量名保留，作为值来源）

    // 校验：客服是否存在且为客服角色（此处adminId是查询Admin的条件，无需修改）
    const admin = await Admin.findById(adminId);
    if (!admin || admin.role !== 'customer_service') {
      return res.json({ code: '2012', msg: '客服不存在或无沟通权限', data: null });
    }

    // 检查是否已有活跃会话（关键修改：用模型字段authorId/serviceId查询）
    const existingSession = await Session.findOne({
      authorId: writerId, // 模型字段 = 作家ID变量（原writerId的值映射到authorId）
      serviceId: adminId, // 模型字段 = 客服ID变量（原adminId的值映射到serviceId）
      status: 'active'
    });
    if (existingSession) {
      return res.json({
        code: '2013',
        msg: '已存在与该客服的会话，可直接进入',
        data: { sessionId: existingSession._id }
      });
    }

    // 创建新会话（关键修改：用模型字段authorId/serviceId存储）
    const newSession = new Session({
      authorId: writerId, // 作家ID存入模型的authorId字段
      serviceId: adminId, // 客服ID存入模型的serviceId字段
      status: 'active'
    });
    await newSession.save();

    // 返回数据（同步修改字段名，与模型/存储一致）
    res.json({
      code: '0000',
      msg: '会话创建成功',
      data: {
        sessionId: newSession._id,
        authorId: newSession.authorId, // 替换原writerId
        serviceId: newSession.serviceId, // 替换原adminId
        status: newSession.status,
        createTime: newSession.createTime
      }
    });
  } catch (err) {
    // 捕获异常，返回明确的错误信息
    console.error('创建会话失败：', err); // 打印错误详情，便于定位（比如数据库字段缺失）
    return res.json({
      code: '500',
      msg: '服务异常：' + err.message, // 把具体错误信息返回给前端（调试阶段用）
      data: {}
    });
  }
});

//发送消息
router.post('/service/send', authenticateToken, async (req, res) => {
  try {
    // 1. 接收请求体参数（严格匹配Message模型的必填字段）
    const {
      sessionId,
      senderType,
      senderId,
      receiverType,
      receiverId,
      content
    } = req.body;

    // 2. 校验必传参数（缺失则返回错误）
    if (!sessionId || !senderType || !senderId || !receiverType || !receiverId || !content) {
      return res.json({ code: '2021', msg: '会话ID、发送方/接收方信息、消息内容不能为空', data: null });
    }

    // 3. 校验senderType和receiverType是否符合枚举值（User/Admin）
    const validTypes = ['User', 'Admin'];
    if (!validTypes.includes(senderType) || !validTypes.includes(receiverType)) {
      return res.json({ code: '2022', msg: '发送方/接收方类型只能是User或Admin', data: null });
    }

    // 4. 校验关联的会话是否存在且活跃（避免往无效会话发消息）
    const session = await Session.findById(sessionId);
    if (!session) {
      return res.json({ code: '2023', msg: '会话不存在', data: null });
    }
    if (session.status !== 'active') {
      return res.json({ code: '2024', msg: '会话已关闭，无法发送消息', data: null });
    }

    // 5. 创建消息实例（自动填充默认值）
    const newMessage = new Message({
      sessionId,
      senderType,
      senderId,
      receiverType,
      receiverId,
      content,
      sendTime: new Date(), // 自动填充当前发送时间
      isRead: false // 默认未读（接收方未查看）
    });

    // 6. 保存消息到数据库
    await newMessage.save();

    // 7. 返回成功结果（包含完整消息信息）
    res.json({
      code: '0000',
      msg: '消息发送成功',
      data: {
        messageId: newMessage._id,
        sessionId: newMessage.sessionId,
        senderType: newMessage.senderType,
        senderId: newMessage.senderId,
        receiverType: newMessage.receiverType,
        receiverId: newMessage.receiverId,
        content: newMessage.content,
        sendTime: newMessage.sendTime,
        isRead: newMessage.isRead
      }
    });
  } catch (err) {
    res.json({ code: '2025', msg: '消息发送失败: ' + err.message, data: null });
  }
});

//获取历史聊天记录
router.get('/service/history', authenticateToken, async (req, res) => {
  try {
    // 1. 接收查询参数（sessionId必传，分页参数可选）
    const {
      sessionId,
      page = 1, // 默认第1页
      pageSize = 20 // 默认每页20条
    } = req.query;

    // 2. 校验sessionId必传
    if (!sessionId) {
      return res.json({ code: '2031', msg: '会话ID不能为空', data: null });
    }

    // 3. 校验会话是否存在（避免查询无效会话）
    const session = await Session.findById(sessionId);
    if (!session) {
      return res.json({ code: '2032', msg: '会话不存在', data: null });
    }

    // 4. 分页计算（skip：跳过前面的条数，limit：当前页最大条数）
    const skip = (page - 1) * pageSize;

    // 5. 查询历史消息（按发送时间倒序，关联会话）
    const messages = await Message.find({ sessionId })
      .sort({ sendTime: 1 }) //1：正序（最早消息在前）
      .skip(skip)
      .limit(Number(pageSize))
      .lean(); // lean()：返回纯JS对象，性能更好

    // 6. 查询总消息数（用于前端分页控件计算总页数）
    const total = await Message.countDocuments({ sessionId });

    // 7. 返回结果（包含消息列表和分页信息）
    res.json({
      code: '0000',
      msg: '历史消息查询成功',
      data: {
        list: messages, // 当前页消息列表
        pagination: {
          page: Number(page),
          pageSize: Number(pageSize),
          total, // 总消息数
          totalPage: Math.ceil(total / pageSize) // 总页数
        }
      }
    });
  } catch (err) {
    res.json({ code: '2033', msg: '历史消息查询失败: ' + err.message, data: null });
  }
});

//获取客服信息
router.get('/service/userinfo', authenticateToken, async (req, res) => {
  try {
    res.setHeader('Cache-Control', 'no-cache, no-store, must-revalidate');
    res.setHeader('Pragma', 'no-cache');
    res.setHeader('Expires', '0');
    // 关键修改：从查询参数中获取“目标客服的adminId”，而非从Token取当前用户ID
    const { adminId } = req.query; 
    console.log('adminId--:', adminId); // 看adminId是否有值
    // 校验adminId是否传递
    if (!adminId) {
      return res.json({
        code: '2009',
        msg: '请传入客服ID',
        data: null
      });
    }

    // 根据adminId查询指定客服信息，排除密码字段
    const admin = await Admin.findById(adminId).select('-password');
    
    if (!admin || admin.role !== 'customer_service') { // 额外校验是否为客服角色
      return res.json({
        code: '2008',
        msg: '客服不存在或无沟通权限',
        data: null
      });
    }
    
    res.json({
      code: '0000',
      msg: '获取客服信息成功',
      data: {
        id: admin._id,
        username: admin.username,
        nickname: admin.nickname, // 客服真实昵称（前端要用这个）
        role: admin.role,
        status: admin.status, // 客服在线状态（online/busy/offline）
        avatar:admin.avatar
      }
    });
  } catch (err) {
    res.json({
      code: '2001',
      msg: '获取客服信息失败: ' + err.message,
      data: null
    });
  }
});


module.exports = router;